基于流形距离的聚类算法

在家蹲了一个月照顾小孩，完全被洗脑了，程序代码是神马，能吃么？

今天回来，决定练练脑，瞎看了会儿黎曼几何的入门知识，突然觉得没准儿可以用在聚类上，检索了一下，果然有相关的文章。

找到一篇论文，先试试看。《基于流形距离的聚类算法研究及其应用》 http://download.csdn.net/download/deltatang/7614279

通过流形聚类，主要是要解决一些特殊的情况：比如凹集合。

欧式几何的距离公式做出来的聚类在三维空间基本上是个球。高维空间就是超球。总之，聚类出来的结果很多时候让人感叹：有个球用啊。。。。。。

跳到二维空间看看形象的表示：

而用欧氏距离加上K-Means聚类出来的东东是这样的：

所以，先抄写一段公式：

所以要实现的距离公式就是 流形上的单源最短路径

参考公式加上 dijkstra 算法，实现的代码如下：

from math import *

_inf = float('inf')
_ldist_p = 1.1

def riemann_dist(Xi, Xj) :
    total = 0.0
    for i in range(len(Xi)) :
        total += (Xi[i] - Xj[i]) ** 2
    dist = sqrt(total)

    global _ldist_p
    return pow(_ldist_p, dist) - 1

def euclid_dist(Xi, Xj) :
    total = 0.0
    for i in range(len(Xi)) :
        total += (Xi[i] - Xj[i]) ** 2
    return sqrt(total)

def matrix(vexlist, dist_func) :
    array = []
    size = len(vexlist)
    for i in range(size) :
        vexi = vexlist[i]
        array.append([])
        for j in range(size) :
            if i == j :
                array[i].append(0)
            else :
                dist = dist_func(vexlist[i], vexlist[j])
                array[i].append(dist)
    return array
                

def dijkstra(start, end, matrix) :        
    path = [0]
    size = len(matrix)

    dist = [k for k in matrix[start]]
    
    while True :
        if len(path) > 1 :
            idx = path[-1]
            row = matrix[idx]
            val = dist[idx]
            
            for i in range(size) :
                if i in path :
                    continue
                orig = dist[i]
                caculate = val + row[i]
                if orig > caculate :
                    dist[i] = caculate

        curdist = []
        for i in range(size) :
            if i not in path :
                curdist.append(dist[i])
                
        cur = dist.index(min(curdist))
        path.append(cur)

        if cur == end or len(path) == size - 1 :
            break

    return dist[end]

def manifold_dist(vexlist, start, end) :
    m = matrix(vexlist, riemann_dist)
    return dijkstra(start, end, m)

'''---------------------------main---------------------------'''
if __name__ == '__main__':  
    print euclid_dist((0, 3), (4, 0))
    print riemann_dist((0, 3), (4, 0))

    vexlist = [(0, 0), (1, 1), (2, 2)]
    print matrix(vexlist, riemann_dist)

    m = [[0, _inf, 10, _inf, 30, 100],
         [_inf, 0, 5, _inf, _inf, _inf],
         [10, 5, 0, _inf, 50, _inf, _inf],
         [_inf, _inf, 50, 0, 20, 10],
         [30, _inf, _inf, 20, 0, 60],
         [100, _inf, _inf, 10, 60, 0]
         ]
    print dijkstra(0, 3, m)
    print manifold_dist(vexlist, 0, 2)

关于dijkstra的实现，看这里看这里 http://www.cppblog.com/eryar/archive/2013/01/01/196897.html

当然，完成了距离公式，还得往k-means里面套，

关于k-means， 看这里看这里 http://www.daniweb.com/software-development/python/threads/31449/k-means-clustering

英文麻烦？看这里看这里 http://www.blogjava.net/Skynet/archive/2009/08/07/290242.html

下做个记录， 改天有空再来填坑， 毕竟还没验证呢：） 现在该看球咯。荷兰队满赛！